The Java Developer's Guide to Eclipse, 2/e

購買商店

---

The Java Developer's Guide to Eclipse, 2/e

$2,310.00

馬上購買

---

內容描述

---

Table
of Contents:

Foreword.
Preface.
    Origin of the Book.
    Goals.
    Intended Audience and Prerequisites.
    How the Book Is Organized.
    Coding Conventions.
    CD-ROM.
    Where to Find Further Information.
Guide to Reading
This Book.
Acknowledgments.

About the
Authors.

1. Read Me
   First.
       Eclipse as a Host for Application Development
   Tools.
       Beyond Tools: Eclipse as a Host for Client
   Applications.
       What Is Eclipse?
       Getting and Installing Eclipse.
       Chapter Summary.
       References.
   I. USING
   ECLIPSE.
2. Getting
   Started with Eclipse.
       Your First Steps.
       Basic Eclipse Use.
       Resource Management.
       Customizing Eclipse.
       Exercise Summary.
       Chapter Summary.
       Reference.
3. Using Java
   Development Tools.
       Getting Started with JDT.
       Writing Java Code.
       Working with Java Elements.
       Tuning the Performance of the JDT.
       More on the JDT Views and Preferences.
       Exercise Summary.
       Chapter Summary.
       Reference.
4. Running and
   Debugging Java.
       Running Java Code.
       Debugging.
       Remote Debugging.
       Exercise Summary.
       Chapter Summary.
       Reference.
5. Teaming Up
   with Eclipse.
       Eclipse Support for CVS.
       General Team Support by Eclipse.
       An Overview of CVS for the Novice.
       The CVS User Interface in Eclipse.
       Special Situations and How to Handle Them.
       Additional Features.
       Exercise Summary.
       Chapter Summary.
       References.
6. Managing Your
   Eclipse Environment.
       An Overview of Your Eclipse Installation.
       Understanding the Runtime Configuration.
       Coordinating Preferences.
       Understanding Configuration Management
   Fundamentals.
       Interacting with the Update Manager.
       Managing Your Configuration.
       Chapter Summary.
       Reference.
   II. FUNDAMENTALS
   OF EXTENDING ECLIPSE.
7. Extending
   Eclipse for Fun and Profit.
       Excited About Extending Eclipse? You Should Be!

    An Easy and Practical Example.
    A Brief Tour of "Hello, World".
    Asking the Right Question Is More Important
Than Knowing the Answer.
    Where to Go from Here?

1. Overview of
   the Eclipse Architecture.
       That Was Then, This Is Now.
       Architectural Top Priorities: Extensibility and
   Integration.
       Eclipse the IDE Platform and Rich Client
   Application.
       The Eclipse Platform Runtime.
       User Interface Frameworks.
       Workbench Frameworks.
       Chapter Summary.
       References.
2. Getting
   Started: Plug-in Development.
       Getting Started with Plug-ins.
       Getting Started with Extensions and Extension
   Points.
       Basic Steps of Implementing a Plug-in.
       Using the Plug-in Development Environment.
       Exercise Summary.
       Chapter Summary.
       References.
3. Creating
   Applications Using the Rich Client Platform.
       Reasons Applications Are Being Built on the
   RCP.
       Eclipse Architecture, Revisited.
       Opportunities for Reuse of Eclipse.
       Implementing Your Own Workbench.
       Exercise Summary.
       Chapter Summary.
       References.
4. Creating
   Extension Points: How Others Can Extend Your Plug-ins.
       Relationship Between Extension Points and
   Extensions.
       Viewing the Official List of Enabled Plug-ins,
   Extensions, and Extension Points.
       How to Define Extension Points.
       Handling Dynamic Plug-ins.
       How to Enable the Schema-Based New Extension
   Wizard.
       Example Summary.
       Chapter Summary.
       References.
5. Advanced
   Plug-in Development.
       Migrating Your Plug-ins from Eclipse 2.1.
       Plug-in Class Loader.
       Runtime Discovery and Delayed Loading.
       Forcing Early Plug-in Activation.
       Plug-in Granularity.
       Plug-in Fragments.
       Chapter Summary.
       References.
6. Defining
   Features and Products.
       Features.
       Products.
       Exercise Summary.
       Chapter Summary.
       References.
   III. EXTENDING
   THE ECLIPSE WORKBENCH.
7. The Standard
   Widget Toolkit: A Lean, Mean Widget Machine.
       The Basic Structure of an SWT Application.
       Common SWT Widgets.
       Responding to Events.
       How to Arrange SWT Widgets Using Layout
   Managers.
       Error Handling.
       Widgets Have Special Disposal Requirements.

    Using Threads to Separate UI and Non-UI
Activities.
    An Overview of SWT Packages.
    SWT Support for Swing.
    Eclipse Forms.
    Example Summary.
    Chapter Summary.
    References.

1. JFace
   Viewers.
       Viewer Basics.
       Viewer Framework.
       Creating the Basic Content Viewer Arrangement.

    Controlling the Content Displayed in a
Structured Viewer.
    Interacting with Viewer Objects.
    Using Alternative Viewer Types.
    Advanced Workbench Integration Options.
    Example Summary.
    Chapter Summary.
    References.

1. Dialogs and
   Wizards.
       Dialogs-The User Interface Beyond Workbench
   Parts.
       Contributing to the Preferences Dialog.
       Contributing to the Properties Dialog.
       Contributing Wizards.
       Directly Opening a Wizard Dialog for Your
   Wizard.
       Example Summary.
       Chapter Summary.
       References.
2. Dialog
   Settings, Preferences, and User Settings.
       Overview of the Options.
       Storing Values in Dialog Settings.
       Storing Preference Values for a Plug-in.
       Scoped Value Management with User Settings.

    Example Summary.
    Chapter Summary.
    References.

1. Views.
       Views: The General-Purpose Workbench Part.
       View Implementation.
       Supporting Action Contributions.
       Interacting with Other Workbench Components.

    Examples Summary.
    Chapter Summary.
    References.

1. Editors.

    Editor Behavior and Architecture.
    Basic Implementation Steps.
    Beyond the Basic Implementation Steps.
    Example Summary.
    Chapter Summary.
    References.

1. Perspectives.
       Creating a Perspective.
       Using the perspectiveExtensions Extension
   Point.
       Example Summary.
       Chapter Summary.
       Reference.
2. Action
   Contributions: The Integration Fast Track.
       Action Contribution Extension Points.
       The Fundamentals of Action Contributions.
       Contributing to the Workbench Menu Bar and
   Toolbar.
       Contributing to the View's Menu and Toolbar.

    Contributing to an Editor's Menu and Toolbar.

    Contributing Context Menus to Views and
Editors.
    Assigning Accelerator Keys to Your Actions.

    Example Summary.
    Chapter Summary.
    References.

1. Providing
   Help.
       Integrating Your Online Documentation.
       Creating Context-Sensitive Help.
       Running the Standalone Help Infocenter.
       Customizing Your Help System.
       Example Summary.
       Chapter Summary.
       References.
   IV. EXTENDING
   THE ECLIPSE IDE.
2. Workspace
   Resource Programming.
       Resource Concepts.
       Workspace API.
       Resource Properties.
       Processing Workspace Resource Change Events.

    Resource Modification Event Management.
    Using Workspace Save Events to Save Critical
Data.
    Examples Summary.
    Chapter Summary.
    References.

1. Managing
   Resources with Natures and Builders.
       Customizing Project Processing.
       Defining and Implementing a Nature.
       Defining and Implementing an Incremental
   Project Builder.
       Example Summary.
       Chapter Summary.
       References.
2. Resource
   Tagging Using Markers.
       Using Markers.
       Adding New Marker Types.
       Extending Markers with Generators for
   Resolution and Help Support.
       Example Summary.
       Chapter Summary.
       References.
3. Building a
   Custom Text Editor with JFace Text.
       Standard Text Editor Functions.
       Editor Configuration: Customization Points.

    Under the Covers of the Text Editor.
  
  Example Summary.
    Chapter Summary.
    References.

1. Extending
   the Java Development Tools.
       What Is the JDT and What Does It Do?
       Java Model.
       Accessing Reusable JDT Functionality.
       Compiling Java Source Code.
       Analyzing Java Source Code.
       Manipulating Java Source Code.
       Where the JDT Extends Eclipse.
       Extending the JDT User Interface.
       Examples Summary.
       Chapter Summary.
       References.
   V. EXTENSIBILITY
   SPECIAL TOPICS.
2. Serviceability.
       Plug-in Diagnostics: System and Configuration
   Information.
       Eclipse Status Objects: A Status Collector.

    Exception Handling: Error Detection.
    Error Dialogs: Providing Detailed Status in
Error Messages.
    Runtime Tracing: A Runtime Diagnostic Tool.

    Using Tracing in a Production Environment.
    Diagnostics: A Comprehensive Error Log.
    Error Logging: Writing to the Workbench Error
Log.
    Example Summary.
    Chapter Summary.
    Reference.

1. Implementing
   Responsiveness and Concurrency Using Jobs.
       Concurrency Framework.
       Using Jobs.
       User Interaction Options.
       Job Contention Management Options.
       Example Summary.
       Chapter Summary.
       References.
2. Using
   Capabilities to Manage Too Much of a Good Thing.
       Introducing Capabilities.
       The Capabilities Extension Point.
       Defining Primary Wizards.
       The Activities API.
       Defining Your Own Triggers.
       Example Summary.
       Chapter Summary.
       References.
3. Internationalization and Accessibility.
       What Does Internationalization Affect in Your
   Plug-in?
       Internationalization Steps.
       Accessibility.
       Example Summary.
       Chapter Summary.
       References.
4. Performance
   Tuning.
       Why Eclipse Should Start Quickly.
       Diagnosing Startup Problems Using the Runtime
   Spy.
       Case Study: Improving IBM WebSphere Studio's
   Startup.
       Avoiding Performance Regressions Using the
   Performance Monitor.
       Common Solutions to Eclipse-Specific
   Performance Problems.
       Chapter Summary.
       References.
5. Swing
   Interoperability.
       Embedding AWT and Swing in Views and Editors.

    Launch-and-Edit Integration.
    ABCEditor Example-In-Process Invocation.
    Example Summary.
    Chapter Summary.
    References.

1. OLE and
   ActiveX Interoperability.
       COM Support in Eclipse.
       COM Container Support.
       OLE Automation-Accessing Extended Behavior.

    Example Summary.
    Chapter Summary.
    Reference.
VI. EXERCISES.

Exercise 1:
Using Eclipse.
    Section 1: Your First Eclipse Project.
    Section 2: Editors and Views.
    Section 3: Working with Resources.
    Section 4: Perspectives.
    Section 5: Using Multiple Eclipse Windows and
Workspaces.
    Section 6: Getting Assistance.
    Exercise Activity Review.
    References.
Exercise 2:
Using Java Development Tools.
    Section 1: Hello World.
    Section 2: Quick Fix.
    Section 3: Code Generation.
    Section 4: Refactoring.
    Exercise Activity Review.
    References.
Exercise 3:
Running and Debugging Java.
    Section 1: Launch Configurations.
    Section 2: Debugging.
    Section 3: Debugging II.
    Section 4: Debugging Threads.
    Section 5: Remote Debugging.
    Exercise Activity Review.
    References.
Exercise 4:
Developing a Simple Web Commerce Application with Eclipse.
    Exercise Setup.
    Section 1: Setting up the Runtime Environment.

    Section 2: Creating a Project for the Example.

    Section 3: Debugging the Example.
    Section 4: Deploying the Example.
    Exercise Activity Review.
    References.
Exercise 5:
Working as a Team with CVS.
    Exercise Setup.
    Section 1: Getting Started.
    Section 2: Updating, Committing, and Resolving
Conflicts.
    Section 3: Branching and Merging.
    Exercise Activity Review.
    Reference.
Exercise 6:
Developing Your First Plug-in.
    Exercise Setup 954Section 1: "Hello, World" in
Five Minutes or Less.
    Section 2: "Hello, World" with Detailed
Step-by-Step Instructions.
    Section 3: Testing with the Runtime Workbench.

    Section 4: Debugging with the Runtime
Workbench.
    Section 5: Defining a Feature to Support the
Plug-in.
    Section 6: Deploying a Feature and Its
Associated Plug-ins.
    Section 7: Exploring (and Sometimes Correcting)
the Eclipse Platform Code.
    Section 8: Correcting Common Problems.
    Exercise Activity Review.
Exercise 7:
Developing Your First Rich Client Application.
    Exercise Setup.
    Getting Started.
    Section 1: Creating an Application Extension.

    Section 2: Creating a Perspective Extension.

    Section 3: Creating a Workbench Advisor.
    Section 4: Implementing the Application's Main
Program.
    Section 5: Running and Testing Your RCP
Application.
    Section 6: Configuring Workbench Window User
Interface Elements.
    Section 7: Adding Menu and Toolbar Actions.

  
  Section 8: Deploying Your Application.
    Section 9: Adding "Optional" Components.
    Exercise Activity Review.
Exercise 8:
Developing a Rich Client Application with Dynamically Added Plug-ins.
    Exercise Setup.
    Section 1: Create Your RCP Application Launch
Configuration.
    Section 2: Implement Your Plug-in Life Cycle
start() Method.
    Section 3: Implement Your Configurator.
    Section 4: Develop a Simple Plug-in Discovery
Mechanism.
    Section 5: Installing the Bonus Pack
Dynamically.
    Exercise Activity Review.
Exercise 9:
Deploying Your Product Using Features.
    Exercise Setup.
    Section 1: Tasks of a Feature Developer.
    Section 2: Tasks of an Eclipse User.
    Section 3: Tasks of a Product Developer.
    Section 4: Tasks for a Product Service
Team-Implementing an Update Site.
    Section 5: Tasks of an Eclipse User-Redux.
    Exercise Activity Review.
Index.

---